home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / circuits / irsim-ca.2 / irsim-ca / irsim-cap-9.2 / src / utils / Makedep / list.c < prev    next >
C/C++ Source or Header  |  1990-12-23  |  4KB  |  261 lines
  1. /*
  2.  * String List Package
  3.  */
  4.  
  5. #include "makedep.h"
  6.  
  7. extern char *malloc();
  8.  
  9.  
  10. /*
  11.  * GetMem:
  12.  * malloc with error exit.
  13.  */
  14.  
  15. char *GetMem(n)
  16.     int n;
  17.   {
  18.     char *p;
  19.  
  20.     p = malloc(n);
  21.     if (p == NULL)
  22.       {
  23.     fprintf(stderr, "%s: Ran out of memory!\n", MyName);
  24.     exit(1);
  25.       }
  26.     return(p);
  27.   }
  28.  
  29.  
  30. /*
  31.  * MakeList:
  32.  * Create an empty list.
  33.  */
  34.  
  35. StringList *MakeList()
  36.   {
  37.     StringList *ptr;
  38.  
  39.     ptr = (StringList *) GetMem(sizeof(StringList));
  40.     ptr->str = NULL;
  41.     ptr->state = HEADER;
  42.     ptr->dep = NULL;
  43.     ptr->next = NULL;
  44.     return(ptr);
  45.   }
  46.  
  47.  
  48. /*
  49.  * AddList:
  50.  * Add a string to a list.
  51.  */
  52.  
  53. AddList(s, l)
  54.     char *s;
  55.     StringList *l;
  56.   {
  57.     StringList *ptr;
  58.  
  59.     ptr = (StringList *) GetMem(sizeof(StringList));
  60.     ptr->str = GetMem(strlen(s)+1);
  61.     strcpy(ptr->str, s);
  62.     ptr->state = UNPROCESSED;
  63.     ptr->dep = NULL;
  64.     ptr->next = l->next;
  65.     l->next = ptr;
  66.   }
  67.  
  68.  
  69. /*
  70.  * InsertList:
  71.  * Insert a string to a list after the designated record.
  72.  * The same implementation as for AddList can be used.
  73.  */
  74.  
  75. InsertList(s, l)
  76.     char *s;
  77.     StringList *l;
  78.   {
  79.     AddList(s, l);
  80.   }
  81.  
  82.  
  83. /*
  84.  * DeleteList:
  85.  * Delete a string from a list.
  86.  */
  87.  
  88. DeleteList(s, l)
  89.     char *s;
  90.     StringList *l;
  91.   {
  92.     StringList *ptr, *ptr1;
  93.  
  94.     if (l->next == NULL)
  95.       {
  96.     return;
  97.       }
  98.     for (ptr = l; ptr->next != NULL; ptr = ptr->next)
  99.       {
  100.     if (Equal(s, ptr->next->str))
  101.       {
  102.         ptr1 = ptr->next;
  103.         ptr->next = ptr->next->next;
  104.         free(ptr1->str);
  105.         free(ptr1);
  106.         return;
  107.       }
  108.       }
  109.   }
  110.  
  111.  
  112. /*
  113.  * MemberOfList:
  114.  * Determines whether s is a member of l.
  115.  */
  116.  
  117. int MemberOfList(s, l)
  118.     char *s;
  119.     StringList *l;
  120.   {
  121.     StringList *ptr;
  122.  
  123.     for (ptr = l->next; ptr != NULL; ptr = ptr->next)
  124.       {
  125.     if (Equal(s, ptr->str))
  126.       {
  127.         return(TRUE);
  128.       }
  129.       }
  130.     return(FALSE);
  131.   }
  132.  
  133.  
  134. /*
  135.  * DestroyList:
  136.  * Deallocates a list and all its members.
  137.  */
  138.  
  139. DestroyList(l)
  140.     StringList *l;
  141.   {
  142.     StringList *ptr;
  143.  
  144.     while (l->next != NULL)
  145.       {
  146.     ptr = l->next;
  147.     l->next = ptr->next;
  148.     free(ptr->str);
  149.     free(ptr);
  150.       }
  151.     free(l);
  152.   }
  153.  
  154.  
  155. /*
  156.  * MergeLists:
  157.  * Merges list l1 onto the front of list l2.
  158.  * l1 is NOT destroyed in the process.
  159.  */
  160.  
  161. MergeLists(l1, l2)
  162.     StringList *l1;
  163.     StringList *l2;
  164.   {
  165.     StringList *p;
  166.  
  167.     p = l1->next;
  168.     while (p != NULL)
  169.       {
  170.     AddList(p->str, l2);
  171.     p = p->next;
  172.       }
  173.   }
  174.  
  175. /*
  176.  * PrintList:
  177.  * Prints a list preceded by a banner.
  178.  * Intended for diagnostic purposes.
  179.  */
  180.  
  181. PrintList(l, banner)
  182.     StringList *l;
  183.     char *banner;
  184.   {
  185.     printf("%s:\n", banner);
  186.     for (l = l->next; l != NULL; l = l->next)
  187.       {
  188.     printf("  %s,  state: %d\n", l->str, l->state);
  189.       }
  190.   }
  191.  
  192.  
  193. /*
  194.  * AddDepList:
  195.  * Add a dependency record for pi to the dependency list for p.
  196.  */
  197.  
  198. AddDepList(pi, p)
  199.     StringList *pi, *p;
  200.   {
  201.     DepList *ptr;
  202.  
  203.     ptr = (DepList *) GetMem(sizeof(DepList));
  204.     ptr->inclFile = pi;
  205.     ptr->next = p->dep;
  206.     p->dep = ptr;
  207.   }
  208.  
  209.  
  210. /*
  211.  * PrintDepList:
  212.  * Print a dependency list preceded by a banner.
  213.  * Intended for diagnostic purposes.
  214.  */
  215.  
  216. PrintDepList(l, banner)
  217.     StringList *l;
  218.     char *banner;
  219.   {
  220.     DepList *p;
  221.  
  222.     printf("%s:\n", banner);
  223.     for (p = l->dep; p != NULL; p = p->next)
  224.       {
  225.     printf("  %s\n", p->inclFile->str);
  226.       }
  227.   }
  228.  
  229.  
  230. /*
  231.  * CheckDepList:
  232.  * Checks to ensure that all dependency records actually point at a record
  233.  * which is on the IList.
  234.  */
  235.  
  236. CheckDepList(p)
  237.     StringList *p;
  238.   {
  239.     DepList *ptr;
  240.     StringList *p1;
  241.     int ok;
  242.  
  243.     for (ptr = p->dep; ptr != NULL; ptr = ptr->next)
  244.       {
  245.         ok = FALSE;
  246.     for (p1 = IList->next; p1 != NULL; p1 = p1->next)
  247.       {
  248.         if (p1 == ptr->inclFile)
  249.           {
  250.         ok = TRUE;
  251.         break;
  252.           }
  253.       }
  254.     if (!ok)
  255.       {
  256.         fprintf(stderr, "\n%s: dependency %s doesn't point into IList.\n",
  257.                 MyName, ptr->inclFile->str);
  258.       }
  259.       }
  260.   }
  261.